This PR rewrites how Salsa runs fixpoint iterations when multiple cylce heads participate in a cycle (when there are multiple nested cycles).

Motivation

The main motivation for this is that we see a runaway in ty for code like this:

self.x1 = 0
self.x2 = 0

self.y1 = self.y2 + self.y3
self.y2 = self.y1
self.y3 = self.y1 + self.y2

self.z1 = self.y1 + self.z2
self.z2 = self.z1

Or as a graph

flowchart TD
    x1
    x2
    
    y1 --> y2
	y1 --> y3
    y2 --> y1
	y3 --> y1
	y3 --> y2

    z1 --> y1 
    z1 --> z2
    z2 --> z1

Today, we'll run separate fixpoint iterations for y1 <-> y2, y3 <-> y1, and z1 <-> z2.

The downside of this is that Salsa runs the nested fixpoint iterations y1<->y3 to convergence for every y1 <-> y2 iteration. If there are more deeply nested cycles, then each of those inner cycles is run to completion for every y1 <-> y2 and y1 <-> y3 iteration, making the number of iterations dependent on the nesting of queries rather than how quickly the problem converges.

To avoid this, the idea is to identify the strongly connected components in the dependency graph. These are:

• x1 (no dependencies)
• x2 (no dependencies)
• y1, y2, y3
• z1, z2 (only depends on y1 in one direction but not both)

Then, run a fixpoint per strongly connected component. That means, we only run 2 fixpoint iterations for the example above. This ensures that the runtime is bound by how quickly the problem converges and not by how deeply nested our queries are (which creates a tension between granular queries and performance).

Single-threaded implementation

Let's ignore multi-threading first as this only complicates things ;)

The change in itself isn't that complicated:

• execute_maybe_iterate: If the query is part of an outer cycle, then don't remove the cycle head from cycle_heads, set a flag on the memo indicating whether this head has converged, and return the provisional value. The query will iterate as part of the outer cycle
• The outer cycle is the query that, when claiming it, results in a cycle (this tells us it's higher up on the stack)
• If the query is an outer cycle, then:
  • Test if itself and all its inner cycle heads (can be retrieved from memo.cycle_heads) have converged
  • If not, update the iteration count on each cycle head and iterate again
  • Otherwise, mark all the cycle heads as finalized.

That's roughly it :)

Multithreading

Where things get complicated is multithreading. I tried to keep the existing locking (where we wait on cycle heads in some places), but I wasn't able to make it work (there were spurious errors till the end). That's why I ended up rewriting cycle head synchronization from scratch.

What makes cycles tricky is that multiple threads can enter the same cycle simultaneously, each starting from a different cycle head that ultimately resolves to the same outer cycle. The new implementation makes this even trickier because inner cycles now complete immediately without iterating, which results in them releasing their locks. That allows other threads to claim those locks again, which can result in them competing for the same locks forever.

This PR extends Salsa's DependencyGraph with a mechanism to transfer the ownership of a query to another query. Let's say we have a -> b -> a and b -> c -> b. The inner cycle head can transfer its lock to the query a. b then remains locked until c completes (successfully or panicking). Only the thread owning a (because it's the thread holding that lock or it's another thread on which a is blocked on) is allowed to reclaim b.

This ensures that the locks of all cycle heads participating in a query ultimately converge to be owned by a single query/thread. We need to do this for every query that supports cycle handling, even if it isn't a cycle head, because the query could become a cycle head in later iterations (e.g., due to changes in the cycle-entry point).

I also found this approach much easier to reason about than the old approach of "just wait for all cycle heads".

However, there's a downside. It requires acquiring the global DependencyGraph lock and tracking dependencies whenever claiming or releasing any query with cycle handle support that participates in a cycle. We incur this cost even when all queries participating in the cycle run on the same thread; this is also the main reason why converge-diverge's performance regresses. I'm not sure if there's a solution to avoid this.

TODO:

• Documentation
• Investigate perf regressions
• Review if there are any changes necessary to maybe_changed_after
• Investigate why cycle_nested_deep_conditional_changed::the_test sometimes hangs or panics
• Add a test for a panic in a nested cycle